PyTorch দিয়ে একটি সম্পূর্ণ Neural Network প্রজেক্ট

এখানে আমরা PyTorch ব্যবহার করে একটি সম্পূর্ণ Neural Network প্রজেক্ট তৈরি করব, যেখানে আমরা একটি সাধারণ ফিডফরোয়ার্ড নিউরাল নেটওয়ার্ক (Fully Connected Neural Network) তৈরি করব। এই প্রজেক্টে আমরা MNIST ডেটাসেট ব্যবহার করব, যা হাতের লেখা অঙ্কের চিত্র ধারণ করে এবং 0 থেকে 9 পর্যন্ত সংখ্যাগুলিকে শ্রেণীবদ্ধ করতে সহায়ক।

আমরা এই প্রজেক্টের মাধ্যমে:

• ডেটাসেট লোড করা,
• মডেল তৈরি করা,
• মডেল ট্রেনিং এবং টেস্টিং করার সমস্ত প্রক্রিয়া শিখব।

১. প্রয়োজনীয় প্যাকেজ ইনস্টলেশন

প্রথমে PyTorch এবং torchvision ইনস্টল করতে হবে (যা ডেটাসেট লোড করার জন্য ব্যবহৃত হবে):

pip install torch torchvision

২. ডেটাসেট লোড এবং প্রিপ্রসেসিং

আমরা MNIST ডেটাসেট লোড করতে torchvision এর সাহায্য নিবো এবং এটিকে DataLoader ব্যবহার করে ব্যাচ আকারে প্রক্রিয়া করব।

import torch
from torch import nn, optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# ডেটা ট্রান্সফর্ম এবং লোডার তৈরি
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])

# MNIST ডেটাসেট লোড করা
trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
testset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)

# ডেটা লোডার তৈরি
trainloader = DataLoader(trainset, batch_size=64, shuffle=True)
testloader = DataLoader(testset, batch_size=64, shuffle=False)

এখানে MNIST ডেটাসেট লোড করা হয়েছে এবং ডেটাকে [0, 1] স্কেলে সাধারণীকৃত করা হয়েছে। ট্রেনিং এবং টেস্টিং সেটের জন্য আলাদা DataLoader তৈরি করা হয়েছে।

৩. Neural Network মডেল তৈরি করা

এখন, আমরা একটি ফিডফরোয়ার্ড নিউরাল নেটওয়ার্ক (Fully Connected Neural Network) তৈরি করব, যা ইনপুট হিসেবে 28x28 পিক্সেলের গ্রেস্কেল চিত্র গ্রহণ করবে এবং 10টি আউটপুট ক্লাসে শ্রেণীবদ্ধ করবে।

class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(28*28, 128)  # ইনপুট লেয়ার (28x28 পিক্সেল)
        self.fc2 = nn.Linear(128, 64)     # মধ্যবর্তী লেয়ার
        self.fc3 = nn.Linear(64, 10)      # আউটপুট লেয়ার (10 ক্লাস)

    def forward(self, x):
        # ফিডফরোয়ার্ড পাস
        x = x.view(-1, 28*28)  # ইনপুটকে 1D ভেক্টরে রূপান্তরিত করা
        x = torch.relu(self.fc1(x))  # ReLU অ্যাক্টিভেশন
        x = torch.relu(self.fc2(x))  # ReLU অ্যাক্টিভেশন
        x = self.fc3(x)  # আউটপুট
        return x

এখানে আমরা তিনটি লেয়ার তৈরি করেছি:

1. প্রথম লেয়ার: ইনপুট (28x28) থেকে 128টি নিউরনে রূপান্তরিত।
2. দ্বিতীয় লেয়ার: 128টি নিউরন থেকে 64টি নিউরনে রূপান্তরিত।
3. আউটপুট লেয়ার: 64টি নিউরন থেকে 10টি ক্লাসে রূপান্তরিত (MNIST ডেটাসেটের 10টি সংখ্যা)।

৪. লস ফাংশন এবং অপটিমাইজার সেট করা

আমরা CrossEntropyLoss লস ফাংশন ব্যবহার করব এবং SGD অপটিমাইজার ব্যবহার করব।

# মডেল ইনস্ট্যান্স তৈরি
model = SimpleNN()

# লস ফাংশন এবং অপটিমাইজার
criterion = nn.CrossEntropyLoss()  # ক্রস এন্ট্রোপি লস
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)  # অপটিমাইজার

৫. মডেল ট্রেনিং

এখন আমরা মডেল ট্রেনিং শুরু করব। ট্রেনিংয়ের জন্য, আমরা ডেটা লোডার থেকে ব্যাচ আকারে ডেটা নিয়ে ফরওয়ার্ড পাস এবং ব্যাকপ্রোপাগেশন করব।

# মডেল ট্রেনিং
num_epochs = 5  # মোট 5 epoch ট্রেনিং
for epoch in range(num_epochs):
    model.train()  # ট্রেনিং মোডে মডেল
    running_loss = 0.0
    for inputs, labels in trainloader:
        optimizer.zero_grad()  # গ্র্যাডিয়েন্ট শূন্য করা
        outputs = model(inputs)  # মডেল থেকে আউটপুট
        loss = criterion(outputs, labels)  # লস ক্যালকুলেশন
        loss.backward()  # ব্যাকপ্রোপাগেশন
        optimizer.step()  # অপটিমাইজার স্টেপ (ওজন আপডেট)

        running_loss += loss.item()
    
    print(f'Epoch {epoch+1}, Loss: {running_loss / len(trainloader):.4f}')

এখানে আমরা 5 epoch এর জন্য মডেলটি ট্রেনিং করছি, এবং প্রতি epoch এর শেষে লস প্রিন্ট করছি।

৬. মডেল টেস্টিং

একবার ট্রেনিং শেষ হলে, আমরা testloader থেকে টেস্ট ডেটা নিয়ে মডেলের পারফরম্যান্স যাচাই করব।

# মডেল টেস্টিং
model.eval()  # টেস্টিং মোডে মডেল
correct = 0
total = 0

with torch.no_grad():  # টেস্টিং এর সময় গ্র্যাডিয়েন্ট ক্যালকুলেশন বন্ধ
    for inputs, labels in testloader:
        outputs = model(inputs)
        _, predicted = torch.max(outputs, 1)  # সর্বোচ্চ সম্ভাবনা আউটপুট নেওয়া
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy on the test dataset: {100 * correct / total:.2f}%')

এখানে, আমরা টেস্ট ডেটার উপর accuracy যাচাই করছি। torch.max() ব্যবহার করে সর্বোচ্চ প্রেডিক্টেড ক্লাস নির্বাচন করা হয়েছে।

৭. ফুল কোড উদাহরণ

import torch
from torch import nn, optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# ডেটা ট্রান্সফর্ম এবং লোডার তৈরি
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])

# MNIST ডেটাসেট লোড করা
trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
testset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)

trainloader = DataLoader(trainset, batch_size=64, shuffle=True)
testloader = DataLoader(testset, batch_size=64, shuffle=False)

# মডেল তৈরি
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(28*28, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 10)

    def forward(self, x):
        x = x.view(-1, 28*28)
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# মডেল, লস ফাংশন এবং অপটিমাইজার
model = SimpleNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

# ট্রেনিং
num_epochs = 5
for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    for inputs, labels in trainloader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()

    print(f'Epoch {epoch+1}, Loss: {running_loss / len(trainloader):.4f}')

# টেস্টিং
model.eval()
correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in testloader:
        outputs = model(inputs)
        _, predicted = torch.max

(outputs, 1) total += labels.size(0) correct += (predicted == labels).sum().item()

print(f'Accuracy on the test dataset: {100 * correct / total:.2f}%')

### সারাংশ

এই প্রজেক্টে, আমরা **PyTorch** ব্যবহার করে একটি **Neural Network** তৈরি করেছি যা **MNIST** ডেটাসেটের জন্য ট্রেনিং এবং টেস্টিং করেছে। আমরা দেখেছি কিভাবে:
- **ডেটা লোড** এবং **প্রিপ্রসেসিং** করতে হয়,
- একটি **ফিডফরোয়ার্ড নিউরাল নেটওয়ার্ক** তৈরি করা হয়,
- **ট্রেনিং** এবং **টেস্টিং** করা হয়।

এই প্রজেক্টের মাধ্যমে আপনি **PyTorch** এর বেসিক কনসেপ্ট, যেমন **লিনিয়ার লেয়ার**, **ReLU অ্যাক্টিভেশন**, **ক্রস এন্ট্রোপি লস**, এবং **SGD অপটিমাইজার** ব্যবহার করতে শিখেছেন।